Remote debugging systems are becoming evermore important for the growing Web application and Web services industry. These systems allow a developer to monitor, inspect, and control the execution of software running on a remote server. This is especially critical for diagnosing problems that show up after deploying the software, but cannot be reproduced in the local development environment.
Unfortunately, most remote debugging protocols (e.g., the Java™ Debugging Interface (JDI)) are inefficient and resource intensive. These protocols are implemented by sending a constant stream of fine-grained information about debugging requests, state information, and events. This results in a slow and unproductive experience for developers and requires more effective communications bandwidth than is otherwise necessary. Bandwidth utilization problems are exacerbated by the fact that fine grain debugging messages may use only a small portion of the fixed size network packets used to transmit them, increasing communications overhead by transmitting many packets that are largely empty.
To make matters worse, debugging protocols are designed to be synchronous, meaning a debugging client must stop and wait for the results from each request it sends before the client can send another request or continue processing. This “blocking and waiting” behavior often means the end user cannot enter their next command until the remote debugging system responds. Consequently, the user interface becomes sluggish and frustrating for the developer. This is true for both local and remote debugging.
Often, the user isn't even interested in the result returned by the debugger, which immediately gets thrown away when the user enters their next command. For example, users often want to step rapidly through each line of the code to see which instructions are executed under certain conditions. With a synchronous debugging protocol, the user must wait after each step command for the debugger to return information about the new line. However, that information is discarded without being examined as soon as the user enters the next step command.
These problems are more pronounced when the debugging client is a visual Integrated Development Environment (IDE). This IDE will usually generate many requests for debugging information automatically on behalf of the user, based on assumptions about the information the developer will “likely” want to inspect. Thus, when the IDE's assumptions are correct, the IDE can answer the user's most “likely” questions quickly from results cached in memory.
Unfortunately, this eager method for collecting debugging information does not come without a cost, but results in more requests being sent to the debugger and ultimately more waiting for more results that never get used. Some IDEs attempt to reduce the amount of information they request. However, when the user requests a piece of information the IDE did not anticipate, the user must wait longer for the IDE to request that information from the debugger. At a minimum, the IDE may request debugging information about running application state that is immediately visible to the programmer in the IDE. For example, FIG. 1 illustrates an IDE with the current local variables and current call stack visible. In this case, the IDE may request only information about each variable displayed in the local variables window and each frame of the call stack shown in the call stack window. However, if the user is just stepping through the executed instructions rapidly, she may never even look at these windows. Therefore, the information collected at each step is never actually used and the time and resources spent collecting this information is wasted.